home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 6 / FM Towns Free Software Collection 6.iso / t_os / et / src / file.c < prev    next >
Text File  |  1993-07-08  |  12KB  |  449 lines
  1. #include  "et.h"
  2. int   save_key(int file_i)/*et*/
  3. {
  4.   FILE  *File;
  5.   int   i, mm, key_n;
  6.   char  *c_p, *demo_p;
  7.   char  *file_p;
  8.   unsigned int f;
  9.  
  10.   key_n = nb_key(G_mv);
  11.   if (test_bit(G_f, f_DEMO)) {
  12.     if (file_i < 0)
  13.       return(1);
  14.     G_bf.key_icn[G_nb.key+1] = G_pn.key_fp;
  15.     _far_copy_buf(0x14,P_v[v_ICN], 0x120, G_pn.key_fp, P_i[i_SIZE_ICN][0]);
  16.     G_pn.key_fp += P_i[i_SIZE_ICN][0];
  17.     if (G_nb.key == 7)  /* 未使用 VRAM が足りないので切り詰め(^^; */
  18.       G_bf.key[8] = G_pn.fp = G_bf.key[1];
  19.     else
  20.       G_bf.key[G_nb.key+1] = G_pn.fp; /* for load_key() */
  21.     c_p = P_c[c_CSR];
  22.     do {
  23.       _poke_byte(0x120, G_pn.fp++, *c_p);
  24.     } while (*c_p++ != EOC);
  25.     make_idx(file_i);
  26.     switch(G_nb.key) {  /* 切り詰め */
  27.     case 2:
  28.     case 3:
  29.     case 4:
  30.     case 6:
  31.     case 8:
  32.       break;
  33.     default:
  34.       _poke_longword(0x120, G_pn.fp, key_n);
  35.       G_pn.fp += sizeof(int);
  36.       _far_copy_buf(0x14, G_mv, 0x120, G_pn.fp, sizeof(MOVE)*(key_n+1));
  37.       G_pn.fp += sizeof(MOVE)*(key_n+1);
  38.       _far_copy_buf(0x14, &G_pm, 0x120, G_pn.fp, sizeof(PARAMETER));
  39.       G_pn.fp += sizeof(PARAMETER);
  40.       f = test_bit(G_f, (f_AA|f_NN));
  41.       _far_copy_buf(0x14, &f, 0x120, G_pn.fp, sizeof(G_f));
  42.       G_pn.fp += sizeof(G_f);
  43.       break;
  44.     }
  45.     return(1);
  46.   }
  47.   mm = file_i;
  48.   if (file_i < 0) {
  49.     file_i = 0;
  50.     file_p = P_c[c_FILE_BAK];
  51.   } else
  52.     file_p = P_c[c_FILE_KEY];
  53.   set_file_i(&file_p[8], file_i);
  54.   File = et_fopen(file_p, "wb", NULL);
  55.   G_nb.drive = *file_p;
  56.   et_fwrite(P_v[v_ICN], 1, P_i[i_SIZE_ICN][0], File);
  57.   c_p = P_c[c_CSR];
  58.   do {
  59.     fwrite(c_p, 1, 1, File);
  60.   } while (*c_p++ != EOC);
  61.   if (file_i)
  62.     make_idx(file_i);
  63.   et_fwrite(&key_n, sizeof(int), 1, File);
  64.   et_fwrite(G_mv, sizeof(MOVE), key_n+1, File);
  65.   et_fwrite(&G_pm, sizeof(PARAMETER), 1, File);
  66.   f = test_bit(G_f, f_AA|f_NN|f_RR);
  67.   et_fwrite(&f, sizeof(G_f), 1, File);
  68.   et_fwrite(&G_nb.key_i, sizeof(int), 1, File);
  69.   fclose(File);
  70.   if (mm < 0)
  71.     return(1);
  72.   File = et_fopen(P_c[c_FILE_ICN_KEY], "ab", NULL);
  73.   G_nb.drive = *P_c[c_FILE_ICN_KEY];
  74.   fseek(File, P_i[i_SIZE_ICN][0] * (file_i-1), 0);
  75.   et_fwrite(P_v[v_ICN], 1, P_i[i_SIZE_ICN][0], File);
  76.   fclose(File);
  77.   return(1);
  78. }
  79. int   make_icn(int icn_i, int file_i)/*et*/
  80. {
  81.   FILE  *File, *Temp;
  82.   int   i;
  83.   char  *c_p;
  84.   char  file_a[20];
  85.   
  86.   if (test_bit(G_f, f_DEMO))
  87.     return;
  88.   Temp = et_fopen(P_c[icn_i], "wb", NULL);
  89.   G_nb.drive = *P_c[icn_i];
  90.   i = 0;
  91.   while (1) {
  92.     set_file_i(&P_c[file_i][8], i+1);
  93.     strcpy(file_a, P_c[file_i]);
  94.     File = fopen(file_a, "rb");
  95.     if (!File)
  96.         break;
  97.     copy_file(Temp, File, (int)P_i[i_SIZE_ICN][0]);
  98.     if (file_i == c_FILE_KEY) {
  99.       c_p = P_c[c_CSR];
  100.       do {
  101.         *c_p = fgetc(File);
  102.       } while (*c_p++ != EOC);
  103.       make_idx(i);
  104.     }
  105.     fclose(File);
  106.     i++;
  107.   }
  108.   fclose(Temp);
  109.   return(i);
  110. }
  111. void  load_et(int i_et,int mm)/*et*/
  112. {
  113.   FILE  *File;
  114.   int   i, j;
  115.   int   *p;
  116.   char  *demo_p, file_a[20];
  117.   int   max_i;
  118.   
  119.   max_i = G_nb.edge-G_nb.max_edge;
  120.   if (!i_et) {
  121.     G_nb.edge = nb_EDGE;
  122.     p = P_i[i_CSR_000_ET];
  123.     for (i = 0; i < G_nb.edge; i++)
  124.       for (j = 0; j < 2; j++) {
  125.         G_et[i].xyz[j] = *p++;
  126.         G_et[i].xyz[j+2] = *p++;
  127.         G_et[i].xyz[j+4] = *p++;
  128.       }
  129.   } else
  130.     if (test_bit(G_f, f_DEMO)) {
  131.       demo_p = G_bf.csr[i_et];
  132.       G_nb.edge = _peek_longword(0x120, demo_p);
  133.       demo_p += sizeof(G_nb.edge);
  134.       _far_copy_buf(0x120, demo_p, 0x14, G_et, sizeof(ET)*G_nb.edge);
  135.     } else {
  136.       strcpy(file_a, P_c[c_FILE_CSR]);
  137.       set_file_i(&file_a[8], i_et);
  138.       File = fopen(file_a, "rb");
  139.       if (!test_bit(G_f, f_DEMO|f_MAKE) && !File) {/* 新しいファイルがない */
  140.         file_a[9] = '_';
  141.         File = et_fopen(file_a, "rb", NULL);
  142.       }
  143.       fseek(File, (long)P_i[i_SIZE_ICN][0], 0);
  144.       fread(&G_nb.edge, sizeof(int), 1, File);
  145.       if (G_nb.edge > G_nb.max_edge) {
  146.         fread(G_et, sizeof(ET), G_nb.max_edge, File);
  147.         fread(G_bf.et_buf, sizeof(ET), max_i, File);
  148.         G_nb.edge = G_nb.max_edge;
  149.       } else
  150.         fread(G_et, sizeof(ET), G_nb.edge, File);
  151.       if (!mm)
  152.         fread(&G_pm, sizeof(PARAMETER), 1, File);
  153.       fclose(File);
  154.     }
  155. }
  156. int   load_key(int file_i, int mm)/*et*/
  157. {
  158.   FILE  *File, *Temp;
  159.   int   i, j, key_i, csr_i, key_n, ins_n;
  160.   unsigned int f;
  161.   char  *csr_p;
  162.   char  *demo_p, file_a[20];
  163.   
  164.   if (!file_i) {
  165.     G_mv[0].key = EOK;
  166.     P_c[c_CSR][0] = 0;
  167.     P_c[c_CSR][1] = EOC;
  168.     init_pm();
  169.     G_nb.key_i = G_nb.et = 0;
  170.     res_bit(G_f, f_AA|f_NN|f_RR);
  171.   } else {
  172.     if (mm) {
  173.       key_i = nb_key(G_mv);
  174.       csr_i = nb_csr(P_c[c_CSR]);
  175.       ins_n = instring(S_RET, P_i[i_KEY_MOVE], sizeof(int));
  176.     } else {
  177.       key_i = 0;
  178.       csr_p = P_c[c_CSR];
  179.       ins_n = EOK+1;
  180.     }
  181.     if (test_bit(G_f, f_DEMO)) {
  182.       demo_p = G_bf.key[file_i];
  183.       if (mm)
  184.         while (_peek_byte(0x120, demo_p++) != EOC)
  185.           ;
  186.       else
  187.         do {
  188.           *csr_p = _peek_byte(0x120, demo_p++);
  189.         } while (*csr_p++ != EOC);
  190.       key_n = _peek_longword(0x120, demo_p);
  191.       demo_p += sizeof(int);
  192.       if (key_n + key_i > MAX_KEY)
  193.         key_n = MAX_KEY - key_i;
  194.       _far_copy_buf(0x120, demo_p, 0x14, &G_mv[key_i],sizeof(MOVE)*(key_n+1));
  195.       demo_p += sizeof(MOVE)*(key_n+1);
  196.       G_mv[key_i+key_n].key = EOK;
  197.       if (mm)
  198.         return(1);
  199.       _far_copy_buf(0x120, demo_p, 0x14, &G_pm, sizeof(PARAMETER));
  200.       demo_p += sizeof(PARAMETER);
  201.       _far_copy_buf(0x120, demo_p, 0x14, &f, sizeof(G_f));
  202.       res_bit(G_f, f_AA|f_NN);
  203.       set_bit(G_f, f);
  204.       return(1);
  205.     }
  206.     if (file_i < 0) {
  207.       file_i = 0;
  208.       strcpy(file_a, P_c[c_FILE_BAK]);
  209.     } else
  210.       strcpy(file_a, P_c[c_FILE_KEY]);
  211.     set_file_i(&file_a[8], file_i);
  212.     File = fopen(file_a, "rb");
  213.     if (!test_bit(G_f, f_DEMO|f_MAKE) && !File) {/* 新しいファイルがない */
  214.       file_a[9] = '_';
  215.       File = et_fopen(file_a, "rb", NULL);
  216.     }
  217.     fseek(File, (long)P_i[i_SIZE_ICN][0], 0);
  218.     if (mm)
  219.       while (fgetc(File) != EOC)
  220.         ;
  221.     else
  222.       do {
  223.         *csr_p = fgetc(File);
  224.       } while (*csr_p++ != EOC);
  225.     fread(&key_n, sizeof(int), 1, File);
  226.     if (key_n + key_i > MAX_KEY)
  227.       key_n = MAX_KEY - key_i;
  228.     fread(&G_mv[key_i], sizeof(MOVE), (key_n+1), File);
  229.     G_mv[key_i+key_n].key = EOK;
  230.     if (mm) {
  231.       fclose(File);
  232.       return(1);
  233.     }
  234.     fread(&G_pm, sizeof(PARAMETER), 1, File);
  235.     fread(&f, sizeof(G_f), 1, File);
  236.     res_bit(G_f, f_AA|f_NN|f_RR);
  237.     set_bit(G_f, f);
  238.     fread(&G_nb.key_i, sizeof(int), 1, File);
  239.     fclose(File);
  240.   }
  241.   return(1);
  242. }
  243. void  ren_file(char file_a[], int dst_i, int src_i)/*et*/
  244. {
  245.   int   i;
  246.   char  dst_a[20], src_a[20];
  247.   FILE  *File;
  248.   
  249.   if (!_disk_free(1))
  250.     return;
  251.   i = 1;
  252.   while (1) {
  253.     set_file_i(&file_a[8], i);
  254.     strcpy(dst_a, file_a);
  255.     dst_a[9] = dst_i;
  256.     strcpy(src_a, file_a);
  257.     src_a[9] = src_i;
  258.     File = fopen(src_a, "rb");
  259.     if (File) {
  260.       fclose(File);
  261.       unlink(dst_a);
  262.       rename(src_a, dst_a);
  263.     } else {
  264.       File = fopen(dst_a, "rb");
  265.       if (File)
  266.         fclose(File);
  267.       else
  268.         break;
  269.     }
  270.     i++;
  271.   }
  272. }
  273. int   kill_file(int mm)/*et*/
  274. {
  275.   int   i;
  276.  
  277.   switch(mm) {
  278.   case 1:
  279.     for (i = 0; i <= G_nb.key; i++) {
  280.       set_file_i(&P_c[c_FILE_KEY][8], i);
  281.       unlink(P_c[c_FILE_KEY]);
  282.     }
  283.     for (i = 0; i <= G_nb.csr; i++) {
  284.       set_file_i(&P_c[c_FILE_CSR][8], i);
  285.       unlink(P_c[c_FILE_CSR]);
  286.     }
  287.   case 3:
  288.     unlink(P_c[c_FILE_ICN_KEY]);
  289.     unlink(P_c[c_FILE_ICN_CSR]);
  290.     unlink(P_c[c_FILE_ET_TEMP]);
  291.   case 2:
  292.     for (i = 1; i <= 5; i++) {
  293.       set_file_i(&P_c[c_FILE_BAK][8], i);
  294.       unlink(P_c[c_FILE_BAK]);
  295.     }
  296.     break;
  297.   }
  298. }
  299. void  copy_file(FILE *File_d, FILE *File_s, int n)/*et*/
  300. {
  301.   int   i;    /* G_bf.et_buf をバッファに使用 */
  302.   
  303.   i = (int)G_nb.max_edge*sizeof(ET);
  304.   if (!n)
  305.     return;
  306.   if (n <= i) {
  307.     fread(G_bf.et_buf, 1, n, File_s);
  308.     et_fwrite(G_bf.et_buf, 1, n, File_d);
  309.   } else {
  310.     fread(G_bf.et_buf, 1, i, File_s);
  311.     et_fwrite(G_bf.et_buf, 1, i, File_d);
  312.     n -= i;
  313.     copy_file(File_d, File_s, n);
  314.   }
  315. }
  316. void  save_et(int edge_i, int file_i)/*et*/
  317. {
  318.   FILE  *File;
  319.   char  *file_p;
  320.   
  321.   file_p = P_c[c_FILE_CSR];
  322.   if (test_bit(G_f, f_DEMO)) {
  323.     G_bf.csr_icn[G_nb.csr+1] = G_pn.csr_fp;
  324.     _far_copy_buf(0x14, P_v[v_ICN], 0x120, G_pn.csr_fp,P_i[i_SIZE_ICN][0]);
  325.     G_pn.csr_fp += P_i[i_SIZE_ICN][0];
  326.     G_bf.csr[G_nb.csr+1] = G_pn.fp;
  327.     _poke_longword(0x120, G_pn.fp, edge_i);
  328.     G_pn.fp += sizeof(edge_i);
  329.     _far_copy_buf(0x14, G_bf.et_buf, 0x120, G_pn.fp, sizeof(ET)*edge_i);
  330.     G_pn.fp += sizeof(ET)*edge_i;
  331.     _far_copy_buf(0x14, &G_pm, 0x120, G_pn.fp, sizeof(PARAMETER));
  332.     G_pn.fp += sizeof(PARAMETER);
  333.     return;
  334.   }
  335.   set_file_i(&file_p[8], file_i);
  336.   File = et_fopen(file_p, "wb", NULL);
  337.   G_nb.drive = *file_p;
  338.   et_fwrite(P_v[v_ICN], 1, P_i[i_SIZE_ICN][0], File);
  339.   et_fwrite(&edge_i, sizeof(int), 1, File);
  340.   et_fwrite(G_bf.et_buf, sizeof(ET), edge_i, File);
  341.   et_fwrite(&G_pm, 1, sizeof(PARAMETER), File);
  342.   fclose(File);
  343.   File = et_fopen(P_c[c_FILE_ICN_CSR], "ab", NULL);
  344.   G_nb.drive = *P_c[c_FILE_ICN_CSR];
  345.   fseek(File, P_i[i_SIZE_ICN][0] * (file_i-1), 0);
  346.   et_fwrite(P_v[v_ICN], 1, P_i[i_SIZE_ICN][0], File);
  347.   fclose(File);
  348. }
  349. FILE  *et_fopen(char file_a[], char mm_a[], FILE *Temp)/*et*/
  350. {
  351.   FILE  *File;
  352.   int   menu_i;
  353.   unsigned  f;
  354.   
  355.   switch(mm_a[0]) {
  356.   case 'r':
  357.     File = fopen(file_a, mm_a);
  358.     if (!File) {
  359.       menu_i = mn_ERR_4;
  360.       f = f2_ERR_4;
  361.       DEBUG(file_a, -1, (int)&G_mn[mn_ERR_4].s[10]);
  362.     }
  363.     break;
  364.   default:
  365.     if (!_disk_free(1))
  366.       File = NULL;
  367.     else
  368.       File = fopen(file_a, mm_a);
  369.     if (!File) {
  370.       menu_i = mn_ERR_2;
  371.       f = f2_ERR_2;
  372.     }
  373.     break;
  374.   }
  375.   if (!File) {
  376.     copy_window(P_i[i_WIN_VIEW], P_v[v_VIEW_0], 0x120, PEEK);
  377.     exchange_page();
  378.     copy_window(P_i[i_WIN_VIEW], P_v[v_VIEW_0], 0x120, POKE);
  379.     exchange_page();
  380.     disp_menu(menu_i, NULL, 13, 0);
  381.     res_bit(G_f2, f2_MOUSE);
  382.     set_bit(G_f2, f);
  383.     while (!inkey(ICN)) /* ICN ... skip write_replay() */
  384.       ;
  385.     set_bit(G_f, f_ERR);
  386.     if (Temp)
  387.       fclose(Temp);
  388.     longjmp(G_jb, 0);
  389.   }
  390.   return(File);
  391. }
  392. void  et_fwrite(void *buf_p, int type, int size, FILE *File)/*et*/
  393. {
  394.   int   i;
  395.   
  396.   i = _disk_free(1);
  397.   if (i < type*size) {
  398.     if (i)
  399.       fwrite(buf_p, 1, i, File);
  400.     fclose(File);
  401.     set_err_1();
  402.     set_bit(G_f, f_ERR);
  403.     longjmp(G_jb, 0);
  404.   } else
  405.     fwrite(buf_p, type, size, File);
  406. }
  407. void  set_err_1()/*et*/
  408. {
  409.   draw_mode(1, mn_FREE_SAVE, L_WHT);
  410.   draw_mode(1, mn_FREE_WORK, L_WHT);
  411.   draw_free(1);
  412.   copy_window(P_i[i_WIN_VRAM], P_v[v_VRAM], 0x14, PEEK);
  413.   exchange_page();
  414.   copy_window(P_i[i_WIN_VRAM], P_v[v_VRAM], 0x14, POKE);
  415.   exchange_page();
  416.   disp_menu(mn_ERR_1, NULL, 13, 0);
  417.   res_bit(G_f2, f2_MOUSE);
  418.   set_bit(G_f2, f2_ERR_1);
  419.   while (!inkey(ICN)) /* ICN ... skip write_replay() */
  420.     ;
  421. }
  422. int   read_replay(int j)/*et*/
  423. {
  424.   FILE  *File;
  425.   int   i;
  426.   
  427.   G_nb.replay += j;
  428.   File = et_fopen(P_c[c_FILE_ET_TEMP], "rb", NULL);
  429.   fseek(File, G_nb.replay, 0);
  430.   fread(&i, sizeof(int), 1, File);
  431.   fclose(File);
  432.   G_nb.replay += sizeof(int);
  433.   return(i);
  434. }
  435. void  write_replay(int key)/*et*/
  436. {
  437.   FILE  *File;
  438.   
  439.   File = fopen(P_c[c_FILE_ET_TEMP], "rb");
  440.   if (File) {
  441.     fclose(File);
  442.     File = et_fopen(P_c[c_FILE_ET_TEMP], "ab", NULL);
  443.   } else
  444.     File = et_fopen(P_c[c_FILE_ET_TEMP], "wb", NULL);
  445.   et_fwrite(&key, sizeof(int), 1, File);
  446.   fclose(File);
  447.   G_nb.drive = *P_c[c_FILE_ET_TEMP];
  448. }
  449.